home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / New System Software Extensions / OpenDoc A6 / OpenDoc Parts Framework / OPF / Found / FWString / Sources / FWStrToo.cpp < prev    next >
Encoding:
Text File  |  1994-04-21  |  15.1 KB  |  495 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FWStrToo.cpp
  4. //    Release Version:    $ 1.0d1 $
  5. //
  6. //    Creation Date:        3/28/94
  7. //
  8. //    Copyright:    © 1994 by Apple Computer, Inc., all rights reserved.
  9. //
  10. //========================================================================================
  11.  
  12. #ifndef FWPRISTR_H
  13. #include "FWPriStr.h"
  14. #endif
  15.  
  16. #ifndef FWPRIDEB_H
  17. #include "FWPriDeb.h"
  18. #endif
  19.  
  20. #ifndef FWSTRTOO_H
  21. #include "FWStrToo.h"
  22. #endif
  23.  
  24. #ifndef FWMATH_H
  25. #include "FWMath.h"
  26. #endif
  27.  
  28. #ifndef FWEXCLIB_H
  29. #include "FWExcLib.h"
  30. #endif
  31.  
  32. #include <ctype.h>
  33.  
  34. #ifdef FW_BUILD_MAC
  35. #pragma segment Strings
  36. #endif
  37.  
  38. //========================================================================================
  39. // CLASS FW_CStringTool
  40. //========================================================================================
  41.  
  42. //----------------------------------------------------------------------------------------
  43. // FW_CStringTool::GetTool
  44. //----------------------------------------------------------------------------------------
  45.  
  46. FW_CStringTool*& FW_CStringTool::GetTool()
  47. {
  48.     const int kOffset = 166;
  49.     FW_CStringTool **tool = (FW_CStringTool **)
  50.                 FW_CPrivTaskGlobals::GetTaskGlobals(kOffset);
  51.     return *tool;
  52. }
  53.  
  54. //----------------------------------------------------------------------------------------
  55. //    FW_CStringTool::GetCurrentStringTool
  56. //----------------------------------------------------------------------------------------
  57.  
  58. FW_CStringTool* FW_CStringTool::GetCurrentStringTool()
  59. {
  60.     FW_CStringTool *&gTool = GetTool();
  61.     if (gTool == NULL)
  62.         gTool = FW_NEW(FW_CMinimalStringTool, ());
  63.     return gTool;
  64. }
  65.  
  66. //----------------------------------------------------------------------------------------
  67. //    FW_CStringTool::SetCurrentStringTool
  68. //----------------------------------------------------------------------------------------
  69.  
  70. FW_CStringTool* 
  71. FW_CStringTool::SetCurrentStringTool(FW_CStringTool* tool)
  72. {
  73.     FW_CStringTool *&gTool = GetTool();
  74.     FW_CStringTool* prior = gTool;
  75.     gTool = tool;
  76.     return prior;
  77. }
  78.  
  79. //----------------------------------------------------------------------------------------
  80. //    FW_CStringTool::FW_CStringTool
  81. //----------------------------------------------------------------------------------------
  82.  
  83. FW_CStringTool::FW_CStringTool(FW_Boolean caseSensitive) :
  84.     fCaseSensitive(caseSensitive)
  85. {
  86. }
  87.  
  88. //----------------------------------------------------------------------------------------
  89. //    FW_CStringTool::~FW_CStringTool
  90. //----------------------------------------------------------------------------------------
  91.  
  92. FW_CStringTool::~FW_CStringTool()
  93. {
  94. }
  95.  
  96. //----------------------------------------------------------------------------------------
  97. //    FW_CStringTool::FW_CStringTool
  98. //----------------------------------------------------------------------------------------
  99.  
  100. FW_Boolean FW_CStringTool::SetCaseSensitivity(FW_Boolean caseSensitive)
  101. {
  102.     FW_Boolean prior = fCaseSensitive;
  103.     fCaseSensitive = caseSensitive;
  104.     return prior;
  105. }
  106.  
  107. //----------------------------------------------------------------------------------------
  108. //    FW_CStringTool::ToUpper
  109. //----------------------------------------------------------------------------------------
  110.  
  111. void FW_CStringTool::ToUpper(FW_CTextReader &input, FW_CTextWriter &output)
  112. {
  113.     input.SetPosition(0);
  114.     FW_Char c;
  115.     while ((c=input.GetCharacterAndAdvance()) != FW_kNulCharacter)
  116.     {
  117.         DoConvertToUpper(&c, 1);
  118.         output.PutCharacterAndAdvance(c);
  119.     }
  120. }
  121.  
  122. //----------------------------------------------------------------------------------------
  123. //    FW_CStringTool::ToUpper
  124. //----------------------------------------------------------------------------------------
  125.  
  126. void FW_CStringTool::ToUpper(FW_CString &string)
  127. {
  128.     DoConvertToUpper((FW_Char*) string.fRepresentation, string.fLength);
  129. }
  130.  
  131. //----------------------------------------------------------------------------------------
  132. //    FW_CStringTool::ToLower
  133. //----------------------------------------------------------------------------------------
  134.  
  135. void FW_CStringTool::ToLower(FW_CTextReader &input, FW_CTextWriter &output)
  136. {
  137.     input.SetPosition(0);
  138.     FW_Char c;
  139.     while ((c=input.GetCharacterAndAdvance()) != FW_kNulCharacter)
  140.     {
  141.         DoConvertToLower(&c, 1);
  142.         output.PutCharacterAndAdvance(c);
  143.     }
  144. }
  145.  
  146. //----------------------------------------------------------------------------------------
  147. //    FW_CStringTool::ToLower
  148. //----------------------------------------------------------------------------------------
  149.  
  150. void FW_CStringTool::ToLower(FW_CString &string)
  151. {
  152.     DoConvertToLower((FW_Char*) string.fRepresentation, string.fLength);
  153. }
  154.                                      
  155. //----------------------------------------------------------------------------------------
  156. //    FW_CStringTool::CompareStrings
  157. //----------------------------------------------------------------------------------------
  158.  
  159. FW_StringCompareResult FW_CStringTool::CompareStrings(
  160.                                     const FW_CString &string1,
  161.                                      const FW_CString &string2)
  162. {
  163.     FW_CStringReader reader1(string1);
  164.     FW_CStringReader reader2(string2);
  165.     return DoCompareStrings(reader1, reader2);
  166. }
  167.  
  168. //----------------------------------------------------------------------------------------
  169. //    FW_CStringTool::FindSubString
  170. //----------------------------------------------------------------------------------------
  171.  
  172. FW_Boolean FW_CStringTool::FindSubString(
  173.                                     FW_CTextReader &reader,
  174.                                     const FW_CString &subString,
  175.                                     FW_CharacterPosition &foundPosition)
  176. {
  177.     FW_CStringReader subStringReader(subString);
  178.     return DoFindSubString(reader, subStringReader, foundPosition);
  179. }
  180.                                  
  181. //----------------------------------------------------------------------------------------
  182. //    FW_CStringTool::FindSubString
  183. //----------------------------------------------------------------------------------------
  184.  
  185. FW_Boolean FW_CStringTool::FindSubString(
  186.                         const FW_CString &string,
  187.                         const FW_CString &subString,
  188.                         FW_CharacterPosition &foundPosition,
  189.                         FW_CharacterPosition startPosition)
  190. {
  191.     FW_CStringReader stringReader(string);
  192.     FW_CStringReader subStringReader(subString);
  193.     stringReader.SetPosition(startPosition);
  194.     return DoFindSubString(stringReader, subStringReader, foundPosition);
  195. }
  196.                                  
  197. //----------------------------------------------------------------------------------------
  198. //    FW_CStringTool::Substitute
  199. //----------------------------------------------------------------------------------------
  200.  
  201. FW_Boolean FW_CStringTool::Substitute(FW_CString &string,
  202.                 const FW_CString &searchString,
  203.                 const FW_CString &substitutionString)
  204. {
  205.     FW_CharacterCount position;
  206.     FW_Boolean found = FindSubString(string, searchString, position, 0);
  207.     if (found)
  208.     {
  209.         string.Delete(searchString.GetLength(), position);
  210.         string.Insert(substitutionString, position);
  211.     }
  212.     return found;
  213. }
  214.  
  215. //----------------------------------------------------------------------------------------
  216. //    FW_CStringTool::FindCharacter
  217. //----------------------------------------------------------------------------------------
  218.  
  219. FW_Boolean FW_CStringTool::FindCharacter(
  220.                         const FW_CString &string,
  221.                         FW_Char character,
  222.                         FW_CharacterPosition &foundPosition,
  223.                         FW_CharacterPosition startPosition,
  224.                         FW_FindDirection direction)
  225. {
  226.     FW_CStringReader reader(string);
  227.     reader.SetPosition(startPosition);
  228.     return DoFindCharacter(reader, character, foundPosition, direction);
  229. }
  230.                                 
  231. //----------------------------------------------------------------------------------------
  232. //    FW_CStringTool::FindWhiteSpace
  233. //----------------------------------------------------------------------------------------
  234.  
  235. FW_Boolean FW_CStringTool::FindWhiteSpace(
  236.                         const FW_CString &string,
  237.                         FW_CharacterPosition &foundPosition,
  238.                         FW_CharacterPosition startPosition,
  239.                         FW_FindDirection direction)
  240. {
  241.     FW_CStringReader reader(string);
  242.     reader.SetPosition(startPosition);
  243.     return DoFindWhiteSpace(reader, foundPosition, direction);
  244. }
  245.                                      
  246. //----------------------------------------------------------------------------------------
  247. //    FW_CStringTool::FindNonWhiteSpace
  248. //----------------------------------------------------------------------------------------
  249.  
  250. FW_Boolean FW_CStringTool::FindNonWhiteSpace(
  251.                             const FW_CString &string,
  252.                             FW_CharacterPosition &foundPosition,
  253.                             FW_CharacterPosition startPosition,
  254.                             FW_FindDirection direction)
  255. {
  256.     FW_CStringReader reader(string);
  257.     reader.SetPosition(startPosition);
  258.     return DoFindNonWhiteSpace(reader, foundPosition, direction);
  259. }
  260.                                      
  261. //========================================================================================
  262. // CLASS FW_CMinimalStringTool
  263. //========================================================================================
  264.  
  265. //----------------------------------------------------------------------------------------
  266. //    FW_CMinimalStringTool::FW_CMinimalStringTool
  267. //----------------------------------------------------------------------------------------
  268.  
  269. FW_CMinimalStringTool::FW_CMinimalStringTool(FW_Boolean caseSensitive) :
  270.     FW_CStringTool(caseSensitive)
  271. {
  272. }
  273.  
  274. //----------------------------------------------------------------------------------------
  275. //    FW_CMinimalStringTool::~FW_CMinimalStringTool
  276. //----------------------------------------------------------------------------------------
  277.  
  278. FW_CMinimalStringTool::~FW_CMinimalStringTool()
  279. {
  280. }
  281.  
  282. //----------------------------------------------------------------------------------------
  283. //    FW_CMinimalStringTool::DoCompareStrings
  284. //----------------------------------------------------------------------------------------
  285.  
  286. FW_StringCompareResult FW_CMinimalStringTool::DoCompareStrings(
  287.                                         FW_CTextReader &reader1,
  288.                                          FW_CTextReader &reader2)
  289. {
  290.     FW_StringCompareResult result = kStringsEqual;
  291.  
  292.     FW_Char c1;
  293.     FW_Char c2;
  294.     do
  295.     {
  296.         c1 = reader1.GetCharacterAndAdvance();
  297.         c2 = reader2.GetCharacterAndAdvance();
  298.         if (!fCaseSensitive)
  299.         {
  300.             DoConvertToUpper(&c1, 1);
  301.             DoConvertToUpper(&c2, 1);
  302.         }
  303.     }  while(c1 == c2 && c1 != FW_kNulCharacter);
  304.     
  305.     if (c1 < c2)
  306.     {
  307.         result = kStringOneLess;
  308.     }
  309.     else if (c1 > c2)
  310.     {
  311.         result = kStringOneGreater;
  312.     }
  313.  
  314.     return result;
  315. }
  316.  
  317. //----------------------------------------------------------------------------------------
  318. //    FW_CMinimalStringTool::DoMatchPrefixString
  319. //----------------------------------------------------------------------------------------
  320.  
  321. FW_Boolean FW_CMinimalStringTool::DoMatchPrefixString(
  322.                                         FW_CTextReader &target,
  323.                                          FW_CTextReader &prefix)
  324. {
  325.     FW_Char t;
  326.     FW_Char p;
  327.     
  328.     do 
  329.     {
  330.         t = target.GetCharacterAndAdvance();
  331.         p = prefix.GetCharacterAndAdvance();
  332.         if (!fCaseSensitive)
  333.         {
  334.             DoConvertToUpper(&t, 1);
  335.             DoConvertToUpper(&p, 1);
  336.         }
  337.     } while (p!=FW_kNulCharacter && p==t);
  338.     
  339.     // Either p is FW_kNulCharacter, or p!=t.
  340.     // If p is FW_kNulCharacter, then whether p==t or p!=t, there is a prefix match.
  341.     // If p!=t, then there is not a prefix match only if p!=FW_kNulCharacter.
  342.     // Correct determination of match is therefore p==FW_kNulCharacter.
  343.     
  344.     return p==FW_kNulCharacter;
  345. }
  346.                                          
  347. //----------------------------------------------------------------------------------------
  348. //    FW_CMinimalStringTool::DoFindSubString
  349. //----------------------------------------------------------------------------------------
  350.  
  351. FW_Boolean FW_CMinimalStringTool::DoFindSubString(
  352.                                     FW_CTextReader &searchStringReader,
  353.                                     FW_CTextReader &subStringReader,
  354.                                     FW_CharacterPosition &foundPosition)
  355. {
  356.     FW_Boolean match = FALSE;
  357.     
  358.     foundPosition = searchStringReader.GetPosition();
  359.     FW_CharacterPosition lastPosition = searchStringReader.GetLength() - 
  360.                                         subStringReader.GetLength();
  361.     while (foundPosition <= lastPosition)
  362.     {
  363.         subStringReader.SetPosition(0);
  364.         match = DoMatchPrefixString(searchStringReader, subStringReader);
  365.         if (match)
  366.             break;
  367.         searchStringReader.SetPosition(++foundPosition);
  368.     }
  369.  
  370.     return match;
  371. }
  372.  
  373. //----------------------------------------------------------------------------------------
  374. //    FW_CMinimalStringTool::DoFindCharacter
  375. //----------------------------------------------------------------------------------------
  376.  
  377. FW_Boolean FW_CMinimalStringTool::DoFindCharacter(
  378.                                     FW_CTextReader &reader,
  379.                                     FW_Char character,
  380.                                     FW_CharacterPosition &foundPosition,
  381.                                     FW_FindDirection direction)
  382. {
  383.     if (!fCaseSensitive)
  384.         DoConvertToUpper(&character, 1);
  385.  
  386.     FW_Char c;
  387.     do
  388.     {
  389.         c = reader.PeekCharacter();
  390.         if (!fCaseSensitive)
  391.             DoConvertToUpper(&c, 1);
  392.         if (c == character || c == FW_kNulCharacter)
  393.             break;
  394.         if (direction == FW_kForwards)
  395.             reader.Advance();
  396.         else
  397.             reader.Backup();
  398.     } while(1); 
  399.     
  400.     FW_Boolean match = (c == character);
  401.     if (match)
  402.         foundPosition = reader.GetPosition();
  403.  
  404.     return match;
  405. }
  406.  
  407. //----------------------------------------------------------------------------------------
  408. //    FW_CMinimalStringTool::DoFindWhiteSpace
  409. //----------------------------------------------------------------------------------------
  410.  
  411. FW_Boolean FW_CMinimalStringTool::DoFindWhiteSpace(
  412.                                     FW_CTextReader &reader,
  413.                                     FW_CharacterPosition &foundPosition,
  414.                                     FW_FindDirection direction)
  415. {
  416.     FW_Char c = reader.PeekCharacter();
  417.     while (!DoIsWhiteSpace(c) && c != FW_kNulCharacter)
  418.     {
  419.         if (direction == FW_kForwards)
  420.             reader.Advance();
  421.         else
  422.             reader.Backup();
  423.         c = reader.PeekCharacter();
  424.     }
  425.     
  426.     FW_Boolean match = DoIsWhiteSpace(c);
  427.     if (match)
  428.         foundPosition = reader.GetPosition();
  429.  
  430.     return match;
  431. }
  432.  
  433. //----------------------------------------------------------------------------------------
  434. //    FW_CMinimalStringTool::DoFindNonWhiteSpace
  435. //----------------------------------------------------------------------------------------
  436.  
  437. FW_Boolean FW_CMinimalStringTool::DoFindNonWhiteSpace(
  438.                                     FW_CTextReader &reader,
  439.                                     FW_CharacterPosition &foundPosition,
  440.                                     FW_FindDirection direction)
  441. {
  442.     FW_Char c = reader.PeekCharacter();
  443.     while (DoIsWhiteSpace(c) && c != FW_kNulCharacter)
  444.     {
  445.         if (direction == FW_kForwards)
  446.             reader.Advance();
  447.         else
  448.             reader.Backup();
  449.         c = reader.PeekCharacter();
  450.     }
  451.     
  452.     FW_Boolean match = !DoIsWhiteSpace(c);
  453.     if (match)
  454.         foundPosition = reader.GetPosition();
  455.  
  456.     return match;
  457. }
  458.  
  459. //----------------------------------------------------------------------------------------
  460. //    CLASS FW_CMinimalStringTool::DoIsWhiteSpace
  461. //----------------------------------------------------------------------------------------
  462.  
  463. FW_Boolean FW_CMinimalStringTool::DoIsWhiteSpace(FW_Char character)
  464. {
  465.     return FW_PrimitiveStringIsSpace(character);
  466. }
  467.  
  468. //----------------------------------------------------------------------------------------
  469. //    CLASS FW_CMinimalStringTool::DoConvertToUpper
  470. //----------------------------------------------------------------------------------------
  471.  
  472. void FW_CMinimalStringTool::DoConvertToUpper(FW_Char *chars, FW_CharacterCount length)
  473. {
  474. #if   defined FW_BYTE_CHARACTERS
  475.     for (int i=0; i<length; i++)
  476.         chars[i] = FW_PrimitiveStringToUpper(chars[i]);
  477. #else
  478.     NotYetImplemented();
  479. #endif
  480. }
  481.  
  482. //----------------------------------------------------------------------------------------
  483. //    CLASS FW_CMinimalStringTool::DoConvertToLower
  484. //----------------------------------------------------------------------------------------
  485.  
  486. void FW_CMinimalStringTool::DoConvertToLower(FW_Char *chars, FW_CharacterCount length)
  487. {
  488. #if   defined FW_BYTE_CHARACTERS
  489.     for (int i=0; i<length; i++)
  490.         chars[i] = FW_PrimitiveStringToLower(chars[i]);
  491. #else
  492.     NotYetImplemented();
  493. #endif
  494. }
  495.